home *** CD-ROM | disk | FTP | other *** search
/ PsL Monthly 1993 December / PSL Monthly Shareware CD-ROM (December 1993).iso / prgmming / dos / c / snippet.exe / MOUSE3.C < prev    next >
Encoding:
C/C++ Source or Header  |  1991-08-15  |  9.2 KB  |  353 lines
  1. /* 
  2. ** A series of routines to provide access to MicroSoft (and compatible) 
  3. ** mice.  Consult your mouse documentation for detailed information regarding 
  4. ** each mouse driver function. 
  5. **
  6. ** by Bob Jarvis
  7. */
  8.  
  9. #include <dos.h> 
  10. #define MSMOUSE 0x33 
  11.  
  12. int mouse_present = 0;  /* globally visible */ 
  13.  
  14. /* 
  15. ** Uses driver function 0 to initialize the mouse software to its default  
  16. ** settings.  If no mouse is present it returns 0.  If a mouse is present, it
  17. ** returns -1, and places the value of the mouse type (2 = MicroSoft,
  18. ** 3 = Mouse Systems, other values are possible) in *mousetype.  Also
  19. ** initializes the global variable mouse_present (0 = no mouse, !0 = mouse
  20. ** is available). 
  21. */ 
  22.  
  23. int ms_reset(int *mousetype)
  24. { 
  25.       union REGS workregs; 
  26.  
  27.       workregs.x.ax = 0; 
  28.       int86(MSMOUSE,&workregs,&workregs); 
  29.       *mousetype = workregs.x.bx; 
  30.       mouse_present = workregs.x.ax; 
  31.       return(mouse_present); 
  32. } 
  33.  
  34. /* 
  35. ** Makes the mouse cursor visible. 
  36. */ 
  37.  
  38. int ms_show_cursor(void) 
  39. { 
  40.       union REGS workregs; 
  41.  
  42.       workregs.x.ax = 1; 
  43.       int86(MSMOUSE,&workregs,&workregs); 
  44.       return(-1); 
  45. } 
  46.  
  47. /* 
  48. ** Hides the mouse cursor.  Should be called before changing any portion of 
  49. ** the screen under the mouse cursor. 
  50. */ 
  51.  
  52. int ms_hide_cursor(void) 
  53. { 
  54.       union REGS workregs; 
  55.  
  56.       workregs.x.ax = 2; 
  57.       int86(MSMOUSE,&workregs,&workregs); 
  58.       return(-1); 
  59. } 
  60.  
  61. /* 
  62. ** Obtains information about the mouse position and button status. 
  63. ** Places the current horizontal and vertical positions in *horizpos and 
  64. ** *vertpos, respectively.  Returns the mouse button status, which is 
  65. ** mapped at the bit level as follows: 
  66. **    Bit 0 - left button    \ 
  67. **    Bit 1 - right button    >-- 0 = button up, 1 = button down 
  68. **    Bit 2 - middle button  / 
  69. */ 
  70.  
  71. int ms_get_mouse_pos(int *horizpos, int *vertpos) /* Returns button status */
  72. { 
  73.       union REGS workregs; 
  74.  
  75.       workregs.x.ax = 3; 
  76.       int86(MSMOUSE,&workregs,&workregs); 
  77.       *horizpos = workregs.x.c;
  78.  
  79.       return(workregs.x.bx); 
  80. } 
  81.  
  82. /* 
  83. ** Moves the mouse cursor to a new position. 
  84. */ 
  85.  
  86. int ms_set_mouse_pos(int horizpos, int vertpos)
  87. { 
  88.       union REGS workregs; 
  89.  
  90.       workregs.x.ax = 4; 
  91.       workregs.x.cx = horizpos; 
  92.       workregs.x.dx = vertpos; 
  93.       int86(MSMOUSE,&workregs,&workregs); 
  94.       return(-1); 
  95. } 
  96.  
  97. /* 
  98. ** Obtains information about the last time the specified button  
  99. ** (0 = left, 1 = right, 2 = middle) was pressed.  Returns the current 
  100. ** button status (same format as return from ms_get_mouse_pos() above).
  101. */ 
  102.  
  103. int ms_button_press_status(int  button,
  104.                            int *press_count,
  105.                            int *column,
  106.                            int *row)
  107. { 
  108.       union REGS workregs; 
  109.  
  110.       workregs.x.ax = 5; 
  111.       workregs.x.bx = button; 
  112.       int86(MSMOUSE,&workregs,&workregs); 
  113.       *press_count = workregs.x.bx; 
  114.       *column = workregs.x.cx; 
  115.       *row = workregs.x.dx; 
  116.       return(workregs.x.ax); 
  117. } 
  118.  
  119. /* 
  120. ** Similar to above but obtains information about the last release of the 
  121. ** specified button. 
  122. */ 
  123.  
  124. int ms_button_release_status(int  button,
  125.                              int *release_count,
  126.                              int *column,
  127.                              int *row)
  128. { 
  129.       union REGS workregs; 
  130.  
  131.       workregs.x.ax = 6; 
  132.       workregs.x.bx = button; 
  133.       int86(MSMOUSE,&workregs,&workregs); 
  134.       *release_count = workregs.x.bx; 
  135.       *column = workregs.x.cx; 
  136.       *row = workregs.x.dx; 
  137.       return(workregs.x.ax); 
  138. } 
  139.  
  140. /* 
  141. ** Forces the mouse cursor to remain within the range specified. 
  142. */ 
  143.  
  144. int ms_restrict_horiz(int min, int max)
  145. { 
  146.       union REGS workregs; 
  147.  
  148.       workregs.x.ax = 7; 
  149.       workregs.x.cx = min; 
  150.       workregs.x.dx = max; 
  151.       int86(MSMOUSE,&workregs,&workregs); 
  152.       return(-1); 
  153. } 
  154.  
  155. /* 
  156. ** Forces the mouse cursor to remain within the range specified. 
  157. */ 
  158.  
  159. int ms_restrict_vert(int min, int max)
  160. { 
  161.       union REGS workregs; 
  162.  
  163.       workregs.x.ax = 8; 
  164.       workregs.x.cx = min; 
  165.       workregs.x.dx = max; 
  166.       int86(MSMOUSE,&workregs,&workregs); 
  167.       return(-1); 
  168. } 
  169.  
  170. int ms_define_window(int left, int top, int right, int bottom)
  171. { 
  172.       ms_restrict_horiz(left,right); 
  173.       ms_restrict_vert(top,bottom); 
  174.       return(-1); 
  175. } 
  176.  
  177. /* 
  178. ** Allows the user to set the graphics cursor to a new shape.  Check your 
  179. ** mouse reference manual for full information about the use of this function.
  180. */ 
  181.  
  182. int ms_set_graphics_cursor(int horiz_hotspot,
  183.                            int vert_hotspot, 
  184.                            int seg_shape_tables,
  185.                            int offset_shape_tables) 
  186. { 
  187.       union REGS workregs; 
  188.       struct SREGS segregs; 
  189.  
  190.       workregs.x.ax = 9; 
  191.       workregs.x.bx = horiz_hotspot; 
  192.       workregs.x.cx = vert_hotspot; 
  193.       workregs.x.dx = offset_shape_tables; 
  194.       segregs.es  = seg_shape_tables; 
  195.       int86x(MSMOUSE,&workregs,&workregs,&segregs); 
  196.       return(-1); 
  197. } 
  198.  
  199. /* 
  200. ** Selects either the software or hardware cursor and sets the start and stop 
  201. ** scan lines (for the hardware cursor) or the screen and cursor masks (for 
  202. ** the software cursor).  Consult your mouse reference for more information. 
  203. */ 
  204.  
  205. int ms_set_text_cursor(int type, int screen_mask, int cursor_mask)
  206. { 
  207.       union REGS workregs; 
  208.  
  209.       workregs.x.ax = 10; 
  210.       workregs.x.bx = type; 
  211.       workregs.x.cx = screen_mask; 
  212.       workregs.x.dx = cursor_mask; 
  213.       int86(MSMOUSE,&workregs,&workregs); 
  214.       return(-1); 
  215. } 
  216.  
  217. /* 
  218. ** Obtains the horizontal and vertical raw motion counts since the last 
  219. ** request. 
  220. */ 
  221.  
  222. int ms_read_motion_counters(int *horiz, int *vert)
  223. { 
  224.       union REGS workregs; 
  225.  
  226.       workregs.x.ax = 11; 
  227.       int86(MSMOUSE,&workregs,&workregs); 
  228.       *horiz = workregs.x.cx; 
  229.       *vert  = workregs.x.dx; 
  230.       return(-1); 
  231. } 
  232.  
  233. /* 
  234. ** Sets up a subroutine to be called when a given event occurs. 
  235. ** NOTE: Use with extreme care.  The function whose address is provided MUST 
  236. **    terminate with a far return (i.e. must be compiled using large model).
  237. **    Also, no DOS or BIOS services may be used, as the user-defined function 
  238. **    is (in effect) an extension to an interrupt service routine. 
  239. */ 
  240.  
  241. int ms_set_event_subroutine(int mask, int seg_routine, int offset_routine)
  242. { 
  243.       union REGS workregs; 
  244.       struct SREGS segregs; 
  245.  
  246.       workregs.x.ax = 12; 
  247.       workregs.x.cx = mask; 
  248.       workregs.x.dx = offset_routine; 
  249.       segregs.es  = seg_routine; 
  250.       int86x(MSMOUSE,&workregs,&workregs,&segregs); 
  251.       return(-1); 
  252. } 
  253.  
  254. /* 
  255. ** Turns light pen emulation mode on. 
  256. */ 
  257.  
  258. int ms_light_pen_on(void) 
  259. { 
  260.       union REGS workregs; 
  261.  
  262.       workregs.x.ax = 13; 
  263.       int86(MSMOUSE,&workregs,&workregs); 
  264.       return(-1); 
  265. } 
  266.  
  267. /* 
  268. ** turns light pen emulation mode off. 
  269. */ 
  270.  
  271. int ms_light_pen_off(void) 
  272. { 
  273.       union REGS workregs; 
  274.  
  275.       workregs.x.ax = 14; 
  276.       int86(MSMOUSE,&workregs,&workregs); 
  277.       return(-1); 
  278. } 
  279.  
  280. /* 
  281. ** Sets the sensitivity of the mouse.  Defaults are 8 and 16 for horizontal 
  282. ** and vertical sensitivity (respectively). 
  283. */ 
  284.  
  285. int ms_set_sensitivity(int horiz, int vert)
  286. { 
  287.       union REGS workregs; 
  288.  
  289.       workregs.x.ax = 15; 
  290.       workregs.x.cx = horiz; 
  291.       workregs.x.dx = vert; 
  292.       int86(MSMOUSE,&workregs,&workregs); 
  293.       return(-1); 
  294. } 
  295.  
  296. /* 
  297. ** Sets up a region of the screen inside of which the mouse cursor will 
  298. ** automatically be 'hidden'. 
  299. */ 
  300.  
  301. int ms_protect_area(int left, int top, int right, int bottom)
  302. { 
  303.       union REGS workregs; 
  304.  
  305.       workregs.x.ax = 16; 
  306.       workregs.x.cx = left; 
  307.       workregs.x.dx = top; 
  308.       workregs.x.si = right; 
  309.       workregs.x.di = bottom; 
  310.       int86(MSMOUSE,&workregs,&workregs); 
  311.       return(-1); 
  312. } 
  313.  
  314. /* 
  315. * Similar to ms_set_graphics_cursor() but allows a larger cursor.  Consult 
  316. ** your mouse documentation for information on how to use this function. 
  317. */ 
  318.  
  319. int ms_set_large_graphics_cursor(int width, 
  320.                                  int height, 
  321.                                  int horiz_hotspot, 
  322.                                  int vert_hotspot, 
  323.                                  int seg_shape_tables, 
  324.                                  int offset_shape_tables) 
  325. { 
  326.       union REGS workregs; 
  327.       struct SREGS segregs; 
  328.  
  329.       workregs.x.ax = 18; 
  330.       workregs.x.bx = (width << 8) + horiz_hotspot; 
  331.       workregs.x.cx = (height << 8) + vert_hotspot; 
  332.       workregs.x.dx = offset_shape_tables; 
  333.       segregs.es  = seg_shape_tables; 
  334.       int86x(MSMOUSE,&workregs,&workregs,&segregs); 
  335.       if(workregs.x.ax == -1) 
  336.             return(workregs.x.ax); /* Return -1 if function 18 supported */ 
  337.       else  return(0);             /* else return 0                      */ 
  338. } 
  339.  
  340. /* 
  341. ** Sets the threshold value for doubling cursor motion.  Default value is 64. 
  342. */ 
  343.  
  344. int ms_set_doublespeed_threshold(int speed)
  345. { 
  346.       union REGS workregs; 
  347.  
  348.       workregs.x.ax = 19; 
  349.       workregs.x.dx = speed; 
  350.       int86(MSMOUSE,&workregs,&workregs); 
  351.       return(-1); 
  352. } 
  353.